local love = require 'love'
local fontHandler = require('assets-handler.font-handler')

local drawg = love.graphics.draw
local setColor = love.graphics.setColor
local circle = love.graphics.circle
local printf = love.graphics.printf
local polygon = love.graphics.polygon
local drawRectangle = love.graphics.rectangle
local line = love.graphics.line
local setLineWidth = love.graphics.setLineWidth

local width = Width
local height = Height
local padding = Padding

local totalMatches = 7 -- 总局数
local currentMatch = 1 -- 当前局数
local nodeRadius = 20 -- 节点半径
local visibleNodes = 5 -- 固定显示5个节点
local arrowSpeed = 1.5 -- 箭头动画速度（秒/周期）
local arrowOvershoot = 10 -- 箭头超出右侧节点的像素
local fontSize = 20

local colors = {
    current = {1, 0.5, 0}, -- 当前节点颜色(橙色)
    future = {0, 0.7, 1}, -- 未来节点颜色(蓝色)
    past = {0.7, 0.7, 0.7}, -- 已完成节点颜色(灰色)
    road = {0.3, 0.3, 0.3}, -- 道路颜色(深灰)
    arrow = {0, 0.6, 1, 0.8}, -- 箭头颜色(半透蓝)
    button = {0.2, 0.6, 1}, -- 按钮颜色
    buttonText = {1, 1, 1}, -- 按钮文字颜色
    endNode = {0.8, 0, 0.2}, -- 终点节点颜色(紫红色)
    cross = {0.2275, 0.2627, 0.3137} -- #3A4350(深灰蓝色)
}

local nextButton = {
    x = 0,
    y = 0,
    width = 120,
    height = 40,
    text = "下一局"
}

local arrowAnimations = {} -- 箭头动画状态（存储每个箭头的移动进度 0-1）
local roadY, nodeSpacing, nodeDiameter
local roadYOffset = 3 -- 道路位置偏移
local roadHeight = 6
local textYOffset = 8 -- 文本在节点内的垂直偏移
local matchTexts = {}
local arrowSize = 18 -- 箭头三角形尺寸
local arrowWidth = 10 -- 箭身宽度
local backgroundImage, scale
local crossSize = 45

-- 窗口大小调整及预计算
local function init()
    -- 按钮位置计算
    nextButton.x = (width - nextButton.width) / 2
    nextButton.y = height - nextButton.height - padding * 2

    -- 道路位置计算
    roadY = nodeRadius + padding * 2

    -- 节点间距计算（使用屏幕80%宽度）
    local availableWidth = width * 0.8
    nodeSpacing = availableWidth / (visibleNodes - 1)  -- 5个节点有4个间隔

    -- 节点尺寸预计算
    nodeDiameter = nodeRadius * 2  -- 节点直径（用于文本居中）

    -- 预计算所有局数的文本（1-totalMatches）
    matchTexts = {}
    for match = 1, totalMatches do
        if match == 1 then
            matchTexts[match] = "始"
        elseif match == totalMatches then
            matchTexts[match] = "终"
        else
            local digits = {'一', '二', '三', '四', '五', '六', '七', '八', '九', '十',
                           '十一', '十二', '十三', '十四', '十五', '十六', '十七', '十八', '十九', '二十'}
            matchTexts[match] = digits[match] or tostring(match)
        end
    end

    backgroundImage = love.graphics.newImage("assets/map.jpg")
    scale = width / backgroundImage:getWidth()
end

-- 计算需要显示的5个节点
local function getVisibleMatches()
    local matches = {}

    -- 计算起始节点，确保始终显示5个节点
    local start
    if currentMatch <= 3 then
        start = 1
    elseif currentMatch >= totalMatches - 2 then
        start = totalMatches - 4
    else
        start = currentMatch - 2
    end

    -- 填充可见节点
    for i = 0, visibleNodes - 1 do
        table.insert(matches, start + i)
    end

    return matches
end

local function update(dt)
    -- 更新箭头动画进度
    local visibleMatches = getVisibleMatches()
    for i = 1, #visibleMatches - 1 do
        local from = visibleMatches[i]
        local to = visibleMatches[i + 1]
        -- 只对未来节点的箭头进行动画
        if from >= currentMatch and from < totalMatches then
            local key = from .. "-" .. to
            -- 初始化动画进度
            if not arrowAnimations[key] then
                arrowAnimations[key] = 0
            end
            -- 更新进度（循环动画）
            arrowAnimations[key] = (arrowAnimations[key] + dt / arrowSpeed) % 1
        end
    end
end

-- 绘制按钮
local function drawButton()
    -- 绘制按钮背景（圆角矩形）
    setColor(colors.button)
    drawRectangle('fill', nextButton.x, nextButton.y, nextButton.width, nextButton.height, 5, 5)

    -- 绘制按钮边框
    setColor(0, 0, 0)
    drawRectangle('line', nextButton.x, nextButton.y, nextButton.width, nextButton.height, 5, 5)

    -- 绘制按钮文字
    fontHandler.setChineseFont(fontSize)
    setColor(colors.buttonText)
    printf(nextButton.text, nextButton.x, nextButton.y + 10, nextButton.width, 'center')
end

-- 获取节点颜色
local function getNodeColor(match)
    if match == totalMatches then
        return colors.endNode  -- 终点节点颜色
    elseif match == currentMatch then
        return colors.current  -- 当前节点颜色
    elseif match < currentMatch then
        return colors.past     -- 已完成节点颜色
    else
        return colors.future   -- 未来节点颜色
    end
end

-- 绘制带动画的箭头（三角形从一个节点完整移动到下一个节点）
local function drawAnimatedArrow(fromX, toX, y, progress)
    -- 计算动画范围（从左侧节点中心到右侧节点右侧）
    local startX = fromX - nodeRadius  -- 左侧节点中心
    local endX = toX + arrowOvershoot  -- 右侧节点右侧（带超出量）
    local range = endX - startX

    -- 计算箭头当前位置（根据进度从startX移动到endX）
    local arrowPosX = startX + range * progress

    -- 绘制箭身（固定线段）
    setColor(colors.arrow)
    drawRectangle('fill', fromX, y - arrowWidth/2, toX - fromX, arrowWidth)

    -- 绘制三角形箭头（随进度移动）
    polygon('fill',
        arrowPosX, y, -- 箭头尖端
        arrowPosX - arrowSize, y - arrowSize/2, -- 左上
        arrowPosX - arrowSize, y + arrowSize/2 -- 左下
    )
end

local function drawCross(x, y, crossWidth, crossHeight)
    setColor(colors.cross)
    setLineWidth(2)
    line(x, y, x + crossWidth, y + crossHeight)
    line(x, y + crossHeight, x + crossWidth, y)
end

local function drawTriangle(x, y)
    local tw = 7
    local th = 16
    local thl = 12
    if currentMatch == 7 then
        setColor(colors.endNode)
    else
        setColor(colors.current)
    end
    setLineWidth(2)
    polygon('fill', x, y, x - tw, y - th, x, y - thl, x + tw, y - th)
    setColor(0, 0, 0)
    polygon('line', x, y, x - tw, y - th, x, y - thl, x + tw, y - th)
end

local function draw(newMatch)
    currentMatch = newMatch

    -- 绘制背景
    -- 参数：图片、x、y、旋转角、缩放x、缩放y
    drawg(backgroundImage, 0, 0, 0, scale, scale)

    if currentMatch > 1 then
        drawCross(60, 480, crossSize, crossSize)
    end
    if currentMatch > 2 then
        drawCross(148, 445, crossSize, crossSize)
    end
    if currentMatch > 3 then
        drawCross(210, 370, crossSize, crossSize)
    end
    if currentMatch > 4 then
        drawCross(107, 315, crossSize, crossSize)
    end
    if currentMatch > 5 then
        drawCross(235, 250, crossSize, crossSize)
    end
    if currentMatch > 6 then
        drawCross(76, 170, crossSize, crossSize)
    end

    if currentMatch == 1 then
        drawTriangle(82, 485)
    elseif currentMatch == 2 then
        drawTriangle(170, 452)
    elseif currentMatch == 3 then
        drawTriangle(233, 377)
    elseif currentMatch == 4 then
        drawTriangle(130, 319)
    elseif currentMatch == 5 then
        drawTriangle(259, 257)
    elseif currentMatch == 6 then
        drawTriangle(98, 176)
    elseif currentMatch == 7 then
        drawTriangle(234, 113)
    end

    -- 获取需要显示的5个节点
    local visibleMatches = getVisibleMatches()

    -- 计算中间位置（当前节点应位于屏幕中央）
    local centerX = width / 2

    -- 找到当前节点在可见列表中的索引
    local currentIndex = nil
    for i, match in ipairs(visibleMatches) do
        if match == currentMatch then
            currentIndex = i
            break
        end
    end

    -- 计算第一个可见节点的X坐标（使当前节点居中）
    local firstNodeX = centerX - (currentIndex - 1) * nodeSpacing

    -- 存储所有节点位置（运行时计算，依赖可见节点列表）
    local nodePositions = {}
    for i, match in ipairs(visibleMatches) do
        nodePositions[match] = firstNodeX + (i - 1) * nodeSpacing
    end

    -- 计算实际起点和终点的位置（依赖可见节点，运行时计算）
    local firstActualNode = 1 -- 实际第一个节点（始）
    local lastActualNode = totalMatches -- 实际最后一个节点（终）
    local firstActualX, lastActualX

    if visibleMatches[1] == firstActualNode then
        firstActualX = nodePositions[firstActualNode] -- 可见时直接取位置
    else
        firstActualX = nodePositions[visibleMatches[1]] - (visibleMatches[1] - firstActualNode) * nodeSpacing
    end

    if visibleMatches[#visibleMatches] == lastActualNode then
        lastActualX = nodePositions[lastActualNode] -- 可见时直接取位置
    else
        lastActualX = nodePositions[visibleMatches[#visibleMatches]] + (lastActualNode - visibleMatches[#visibleMatches]) * nodeSpacing
    end

    -- 绘制灰色道路（严格限定在实际起点和终点之间）
    local roadStartX = firstActualX - nodeRadius  -- 第一个实际节点左边缘
    local roadEndX = lastActualX + nodeRadius     -- 最后一个实际节点右边缘
    setColor(colors.road)
    drawRectangle('fill', roadStartX, roadY - roadYOffset, roadEndX - roadStartX, roadHeight)

    -- 绘制节点间的动画箭头
    for i = 1, #visibleMatches - 1 do
        local fromMatch = visibleMatches[i]
        local toMatch = visibleMatches[i + 1]
        local fromX = nodePositions[fromMatch] + nodeRadius  -- 当前节点右边缘
        local toX = nodePositions[toMatch] - nodeRadius      -- 下一个节点左边缘

        -- 只对未来节点绘制箭头
        if fromMatch >= currentMatch and fromMatch < totalMatches then
            local key = fromMatch .. "-" .. toMatch
            local progress = arrowAnimations[key] or 0
            drawAnimatedArrow(fromX, toX, roadY, progress)
        end
    end

    -- 绘制节点
    for _, match in ipairs(visibleMatches) do
        local nodeX = nodePositions[match]

        -- 获取节点颜色
        local nodeColor = getNodeColor(match)
        setColor(nodeColor)

        -- 绘制节点
        circle('fill', nodeX, roadY, nodeRadius)
        setColor(0, 0, 0)  -- 黑色边框
        circle('line', nodeX, roadY, nodeRadius)

        -- 绘制局数文本（使用预计算的文本和尺寸）
        local text = matchTexts[match]
        setColor(0, 0, 0)
        printf(text, nodeX - nodeRadius, roadY - textYOffset, nodeDiameter, 'center')
    end

    -- 绘制按钮
    drawButton()
end

-- 检查点是否在矩形内
local function inArea(x, y)
    return x >= nextButton.x and x <= nextButton.x + nextButton.width and
           y >= nextButton.y and y <= nextButton.y + nextButton.height
end

return{
    init = init,
    draw = draw,
    update = update,
    inArea = inArea
}